const express = require('express');
const router = express.Router();
const { User } = require('../models');
const bcrypt = require('bcryptjs');
const { authenticateToken, isAdmin } = require('../middleware/auth');
const { Op } = require('sequelize');

// 获取所有用户列表（管理员功能）
router.get('/', authenticateToken, isAdmin, async (req, res) => {
  try {
    const { page = 1, limit = 10, search = '' } = req.query;
    const offset = (page - 1) * limit;
    
    // 构建查询条件
    const whereClause = {};
    if (search) {
      whereClause[Op.or] = [
        { username: { [Op.like]: `%${search}%` } },
        { email: { [Op.like]: `%${search}%` } }
      ];
    }
    
    const { count, rows } = await User.findAndCountAll({
      where: whereClause,
      attributes: ['id', 'username', 'email', 'avatar', 'isAdmin', 'created_at'],
      limit: parseInt(limit),
      offset: parseInt(offset),
      order: [['created_at', 'DESC']]
    });
    
    res.json({
      success: true,
      data: {
        users: rows,
        pagination: {
          total: count,
          page: parseInt(page),
          limit: parseInt(limit),
          totalPages: Math.ceil(count / limit)
        }
      }
    });
  } catch (error) {
    console.error('获取用户列表失败:', error);
    res.status(500).json({
      success: false,
      error: '获取用户列表失败',
      message: error.message
    });
  }
});

// 根据ID获取用户详情（管理员功能）
router.get('/:id', authenticateToken, isAdmin, async (req, res) => {
  try {
    const { id } = req.params;
    
    const user = await User.findByPk(id, {
      attributes: ['id', 'username', 'email', 'avatar', 'isAdmin', 'created_at']
    });
    
    if (!user) {
      return res.status(404).json({
        success: false,
        error: '用户不存在'
      });
    }
    
    res.json({
      success: true,
      data: user
    });
  } catch (error) {
    console.error('获取用户详情失败:', error);
    res.status(500).json({
      success: false,
      error: '获取用户详情失败',
      message: error.message
    });
  }
});

// 更新用户信息
router.put('/:id', authenticateToken, async (req, res) => {
  try {
    const { id } = req.params;
    const { username, email, avatar, password } = req.body;
    const currentUserId = req.user.id;
    const isCurrentUserAdmin = req.user.isAdmin;
    
    // 检查权限：只能修改自己的信息，或者管理员可以修改任何用户
    if (parseInt(id) !== currentUserId && !isCurrentUserAdmin) {
      return res.status(403).json({
        success: false,
        error: '权限不足',
        message: '只能修改自己的用户信息'
      });
    }
    
    const user = await User.findByPk(id);
    if (!user) {
      return res.status(404).json({
        success: false,
        error: '用户不存在'
      });
    }
    
    // 检查用户名是否已存在（如果要修改用户名）
    if (username && username !== user.username) {
      const existingUser = await User.findOne({ where: { username } });
      if (existingUser) {
        return res.status(400).json({
          success: false,
          error: '用户名已存在'
        });
      }
    }
    
    // 检查邮箱是否已存在（如果要修改邮箱）
    if (email && email !== user.email) {
      const existingEmail = await User.findOne({ where: { email } });
      if (existingEmail) {
        return res.status(400).json({
          success: false,
          error: '邮箱已存在'
        });
      }
    }
    
    // 准备更新数据
    const updateData = {};
    if (username) updateData.username = username;
    if (email) updateData.email = email;
    if (avatar !== undefined) updateData.avatar = avatar;
    
    // 如果要修改密码，进行加密
    if (password) {
      updateData.password = await bcrypt.hash(password, 10);
    }
    
    // 执行更新
    await user.update(updateData);
    
    // 返回更新后的用户信息（不包含密码）
    const updatedUser = await User.findByPk(id, {
      attributes: ['id', 'username', 'email', 'avatar', 'isAdmin', 'created_at']
    });
    
    res.json({
      success: true,
      message: '用户信息更新成功',
      data: updatedUser
    });
  } catch (error) {
    console.error('更新用户信息失败:', error);
    res.status(500).json({
      success: false,
      error: '更新用户信息失败',
      message: error.message
    });
  }
});

// 删除用户（管理员功能）
router.delete('/:id', authenticateToken, isAdmin, async (req, res) => {
  try {
    const { id } = req.params;
    const currentUserId = req.user.id;
    
    // 防止管理员删除自己
    if (parseInt(id) === currentUserId) {
      return res.status(400).json({
        success: false,
        error: '不能删除自己的账号'
      });
    }
    
    const user = await User.findByPk(id);
    if (!user) {
      return res.status(404).json({
        success: false,
        error: '用户不存在'
      });
    }
    
    // 删除用户
    await user.destroy();
    
    res.json({
      success: true,
      message: '用户删除成功',
      data: {
        deletedUserId: id,
        deletedUsername: user.username
      }
    });
  } catch (error) {
    console.error('删除用户失败:', error);
    res.status(500).json({
      success: false,
      error: '删除用户失败',
      message: error.message
    });
  }
});

// 批量删除用户（管理员功能）
router.delete('/', authenticateToken, isAdmin, async (req, res) => {
  try {
    const { userIds } = req.body;
    const currentUserId = req.user.id;
    
    if (!userIds || !Array.isArray(userIds) || userIds.length === 0) {
      return res.status(400).json({
        success: false,
        error: '请提供要删除的用户ID列表'
      });
    }
    
    // 防止管理员删除自己
    if (userIds.includes(currentUserId)) {
      return res.status(400).json({
        success: false,
        error: '不能删除自己的账号'
      });
    }
    
    // 查找要删除的用户
    const users = await User.findAll({
      where: { id: userIds },
      attributes: ['id', 'username']
    });
    
    if (users.length === 0) {
      return res.status(404).json({
        success: false,
        error: '没有找到要删除的用户'
      });
    }
    
    // 执行批量删除
    const deletedCount = await User.destroy({
      where: { id: userIds }
    });
    
    res.json({
      success: true,
      message: `成功删除 ${deletedCount} 个用户`,
      data: {
        deletedCount,
        deletedUsers: users.map(user => ({
          id: user.id,
          username: user.username
        }))
      }
    });
  } catch (error) {
    console.error('批量删除用户失败:', error);
    res.status(500).json({
      success: false,
      error: '批量删除用户失败',
      message: error.message
    });
  }
});

// 修改用户权限（超级管理员功能）
router.patch('/:id/admin', authenticateToken, isAdmin, async (req, res) => {
  try {
    const { id } = req.params;
    const { isAdmin } = req.body;
    const currentUserId = req.user.id;
    
    // 防止管理员修改自己的权限
    if (parseInt(id) === currentUserId) {
      return res.status(400).json({
        success: false,
        error: '不能修改自己的管理员权限'
      });
    }
    
    const user = await User.findByPk(id);
    if (!user) {
      return res.status(404).json({
        success: false,
        error: '用户不存在'
      });
    }
    
    // 更新管理员权限
    await user.update({ isAdmin: Boolean(isAdmin) });
    
    res.json({
      success: true,
      message: `用户权限${isAdmin ? '提升为管理员' : '降级为普通用户'}成功`,
      data: {
        userId: id,
        username: user.username,
        isAdmin: Boolean(isAdmin)
      }
    });
  } catch (error) {
    console.error('修改用户权限失败:', error);
    res.status(500).json({
      success: false,
      error: '修改用户权限失败',
      message: error.message
    });
  }
});

module.exports = router;